package doxygenxml.compound;
 
/**********************************************************************************************
 * Copyright (c) 2001-2020 Liquid Technologies Limited. All rights reserved.
 * See www.liquid-technologies.com for product details.
 *
 * Please see products End User License Agreement for distribution permissions.
 *
 * WARNING: THIS FILE IS GENERATED
 * Changes made outside of ##HAND_CODED_BLOCK_START blocks will be overwritten
 *
 * Generation  :  by Liquid XML Data Binder 18.0.5.9988
 * Using Schema: CENSORED
 **********************************************************************************************/
	
// <summary>
// This class represents the ComplexType memberdefType
// </summary>
public class MemberdefType extends com.liquid_technologies.ltxmllib18.XmlGeneratedClass {
	private static final long serialVersionUID = 13L;

	// <summary>
	// 	Constructor for MemberdefType
	// </summary>
	// <remarks>
	// The class is created with all the mandatory fields populated with the
	// default data. 
	// All Collection object are created.
	// However any 1-n relationships (these are represented as collections) are
	// empty. To comply with the schema these must be populated before the xml
	// obtained from ToXml is valid against the schema CENSORED
	// </remarks>
	public MemberdefType() {
		setElementName("memberdefType");
		init();
	}
	public MemberdefType(String elementName) {
		setElementName(elementName);
		init();
	}		

	// <summary>
	// 	Initializes the class
	// </summary>
	// <remarks>
	// This creates all the mandatory fields (populated with the default data) 
	// All Collection object are created.
	// However any 1-n relationships (these are represented as collections) are
	// empty. To comply with the schema these must be populated before the xml
	// obtained from ToXml is valid against the schema CENSORED.
	// </remarks>
	@Override
	protected void init() {
		try {
			doxygenxml.compound.Registration.iRegistrationIndicator = 0; // causes registration to take place
			_kind = doxygenxml.compound.DoxMemberKind.Define;
			_isValidKind = false;
			_id = "";
			_isValidId = false;
			_prot = doxygenxml.compound.DoxProtectionKind.public_;
			_isValidProt = false;
			_static = doxygenxml.compound.DoxBool.Yes;
			_isValidStatic = false;
			_strong = doxygenxml.compound.DoxBool.Yes;
			_isValidStrong = false;
			_const = doxygenxml.compound.DoxBool.Yes;
			_isValidConst = false;
			_explicit = doxygenxml.compound.DoxBool.Yes;
			_isValidExplicit = false;
			_inline = doxygenxml.compound.DoxBool.Yes;
			_isValidInline = false;
			_refqual = doxygenxml.compound.DoxRefQualifierKind.Lvalue;
			_isValidRefqual = false;
			_virt = doxygenxml.compound.DoxVirtualKind.NonMinusvirtual;
			_isValidVirt = false;
			_volatile = doxygenxml.compound.DoxBool.Yes;
			_isValidVolatile = false;
			_mutable = doxygenxml.compound.DoxBool.Yes;
			_isValidMutable = false;
			_noexcept = doxygenxml.compound.DoxBool.Yes;
			_isValidNoexcept = false;
			_constexpr = doxygenxml.compound.DoxBool.Yes;
			_isValidConstexpr = false;
			_readable = doxygenxml.compound.DoxBool.Yes;
			_isValidReadable = false;
			_writable = doxygenxml.compound.DoxBool.Yes;
			_isValidWritable = false;
			_initonly = doxygenxml.compound.DoxBool.Yes;
			_isValidInitonly = false;
			_settable = doxygenxml.compound.DoxBool.Yes;
			_isValidSettable = false;
			_privatesettable = doxygenxml.compound.DoxBool.Yes;
			_isValidPrivatesettable = false;
			_protectedsettable = doxygenxml.compound.DoxBool.Yes;
			_isValidProtectedsettable = false;
			_gettable = doxygenxml.compound.DoxBool.Yes;
			_isValidGettable = false;
			_privategettable = doxygenxml.compound.DoxBool.Yes;
			_isValidPrivategettable = false;
			_protectedgettable = doxygenxml.compound.DoxBool.Yes;
			_isValidProtectedgettable = false;
			_final = doxygenxml.compound.DoxBool.Yes;
			_isValidFinal = false;
			_sealed = doxygenxml.compound.DoxBool.Yes;
			_isValidSealed = false;
			_new = doxygenxml.compound.DoxBool.Yes;
			_isValidNew = false;
			_add = doxygenxml.compound.DoxBool.Yes;
			_isValidAdd = false;
			_remove = doxygenxml.compound.DoxBool.Yes;
			_isValidRemove = false;
			_raise = doxygenxml.compound.DoxBool.Yes;
			_isValidRaise = false;
			_optional = doxygenxml.compound.DoxBool.Yes;
			_isValidOptional = false;
			_required = doxygenxml.compound.DoxBool.Yes;
			_isValidRequired = false;
			_accessor = doxygenxml.compound.DoxAccessor.Retain;
			_isValidAccessor = false;
			_attribute = doxygenxml.compound.DoxBool.Yes;
			_isValidAttribute = false;
			_property = doxygenxml.compound.DoxBool.Yes;
			_isValidProperty = false;
			_readonly = doxygenxml.compound.DoxBool.Yes;
			_isValidReadonly = false;
			_bound = doxygenxml.compound.DoxBool.Yes;
			_isValidBound = false;
			_removable = doxygenxml.compound.DoxBool.Yes;
			_isValidRemovable = false;
			_constrained = doxygenxml.compound.DoxBool.Yes;
			_isValidConstrained = false;
			_transient = doxygenxml.compound.DoxBool.Yes;
			_isValidTransient = false;
			_maybevoid = doxygenxml.compound.DoxBool.Yes;
			_isValidMaybevoid = false;
			_maybedefault = doxygenxml.compound.DoxBool.Yes;
			_isValidMaybedefault = false;
			_maybeambiguous = doxygenxml.compound.DoxBool.Yes;
			_isValidMaybeambiguous = false;
			_templateparamlist = null;
			_type = null;
			_definition = null;
			_argsstring = null;
			_name = null;
			_read = null;
			_write = null;
			_bitfield = null;
			_reimplements = new doxygenxml.compound.XmlObjectCollection<doxygenxml.compound.ReimplementType>("reimplements", "", 0, -1, false, doxygenxml.compound.ReimplementType.class);
			_reimplementedby = new doxygenxml.compound.XmlObjectCollection<doxygenxml.compound.ReimplementType>("reimplementedby", "", 0, -1, false, doxygenxml.compound.ReimplementType.class);
			_param = new doxygenxml.compound.XmlObjectCollection<doxygenxml.compound.ParamType>("param", "", 0, -1, false, doxygenxml.compound.ParamType.class);
			_enumvalue = new doxygenxml.compound.XmlObjectCollection<doxygenxml.compound.EnumvalueType>("enumvalue", "", 0, -1, false, doxygenxml.compound.EnumvalueType.class);
			_initializer = null;
			_exceptions = null;
			_briefdescription = null;
			_detaileddescription = null;
			_inbodydescription = null;
			_location = new doxygenxml.compound.LocationType("location");
			_references = new doxygenxml.compound.XmlObjectCollection<doxygenxml.compound.ReferenceType>("references", "", 0, -1, false, doxygenxml.compound.ReferenceType.class);
			_referencedby = new doxygenxml.compound.XmlObjectCollection<doxygenxml.compound.ReferenceType>("referencedby", "", 0, -1, false, doxygenxml.compound.ReferenceType.class);

			// ##HAND_CODED_BLOCK_START ID="Additional Inits"## DO NOT MODIFY ANYTHING OUTSIDE OF THESE TAGS
			// Add Additional initialization code here...
			// ##HAND_CODED_BLOCK_END ID="Additional Inits"## DO NOT MODIFY ANYTHING OUTSIDE OF THESE TAGS

			getClassAttributeInfo();
			getClassElementInfo();
		} catch (Exception ex) {
			// should never happen
			ex.printStackTrace();
			throw new InternalError();
		}
	}



	// <summary>
	// Allows the class to be copied
	// </summary>
	// <remarks>
	// Performs a 'deep copy' of all the data in the class (and its children)
	// </remarks>
	@Override
	public Object clone() throws CloneNotSupportedException {
		try {
			doxygenxml.compound.MemberdefType newObject = (doxygenxml.compound.MemberdefType)super.clone();

			// clone, creates a bitwise copy of the class, so all the collections are the
			// same as the parents. Init will re-create our own collections, and classes, 
			// preventing objects being shared between the new an original objects
			newObject.init();
			newObject._kind = _kind;
			newObject._isValidKind = _isValidKind;
			if (_isValidId)
				newObject._id = _id;
			newObject._isValidId = _isValidId;
			newObject._prot = _prot;
			newObject._isValidProt = _isValidProt;
			newObject._static = _static;
			newObject._isValidStatic = _isValidStatic;
			newObject._strong = _strong;
			newObject._isValidStrong = _isValidStrong;
			newObject._const = _const;
			newObject._isValidConst = _isValidConst;
			newObject._explicit = _explicit;
			newObject._isValidExplicit = _isValidExplicit;
			newObject._inline = _inline;
			newObject._isValidInline = _isValidInline;
			newObject._refqual = _refqual;
			newObject._isValidRefqual = _isValidRefqual;
			newObject._virt = _virt;
			newObject._isValidVirt = _isValidVirt;
			newObject._volatile = _volatile;
			newObject._isValidVolatile = _isValidVolatile;
			newObject._mutable = _mutable;
			newObject._isValidMutable = _isValidMutable;
			newObject._noexcept = _noexcept;
			newObject._isValidNoexcept = _isValidNoexcept;
			newObject._constexpr = _constexpr;
			newObject._isValidConstexpr = _isValidConstexpr;
			newObject._readable = _readable;
			newObject._isValidReadable = _isValidReadable;
			newObject._writable = _writable;
			newObject._isValidWritable = _isValidWritable;
			newObject._initonly = _initonly;
			newObject._isValidInitonly = _isValidInitonly;
			newObject._settable = _settable;
			newObject._isValidSettable = _isValidSettable;
			newObject._privatesettable = _privatesettable;
			newObject._isValidPrivatesettable = _isValidPrivatesettable;
			newObject._protectedsettable = _protectedsettable;
			newObject._isValidProtectedsettable = _isValidProtectedsettable;
			newObject._gettable = _gettable;
			newObject._isValidGettable = _isValidGettable;
			newObject._privategettable = _privategettable;
			newObject._isValidPrivategettable = _isValidPrivategettable;
			newObject._protectedgettable = _protectedgettable;
			newObject._isValidProtectedgettable = _isValidProtectedgettable;
			newObject._final = _final;
			newObject._isValidFinal = _isValidFinal;
			newObject._sealed = _sealed;
			newObject._isValidSealed = _isValidSealed;
			newObject._new = _new;
			newObject._isValidNew = _isValidNew;
			newObject._add = _add;
			newObject._isValidAdd = _isValidAdd;
			newObject._remove = _remove;
			newObject._isValidRemove = _isValidRemove;
			newObject._raise = _raise;
			newObject._isValidRaise = _isValidRaise;
			newObject._optional = _optional;
			newObject._isValidOptional = _isValidOptional;
			newObject._required = _required;
			newObject._isValidRequired = _isValidRequired;
			newObject._accessor = _accessor;
			newObject._isValidAccessor = _isValidAccessor;
			newObject._attribute = _attribute;
			newObject._isValidAttribute = _isValidAttribute;
			newObject._property = _property;
			newObject._isValidProperty = _isValidProperty;
			newObject._readonly = _readonly;
			newObject._isValidReadonly = _isValidReadonly;
			newObject._bound = _bound;
			newObject._isValidBound = _isValidBound;
			newObject._removable = _removable;
			newObject._isValidRemovable = _isValidRemovable;
			newObject._constrained = _constrained;
			newObject._isValidConstrained = _isValidConstrained;
			newObject._transient = _transient;
			newObject._isValidTransient = _isValidTransient;
			newObject._maybevoid = _maybevoid;
			newObject._isValidMaybevoid = _isValidMaybevoid;
			newObject._maybedefault = _maybedefault;
			newObject._isValidMaybedefault = _isValidMaybedefault;
			newObject._maybeambiguous = _maybeambiguous;
			newObject._isValidMaybeambiguous = _isValidMaybeambiguous;
			newObject._templateparamlist = null;
			if (_templateparamlist != null)
				newObject._templateparamlist = (doxygenxml.compound.TemplateparamlistType)_templateparamlist.clone();
			newObject._type = null;
			if (_type != null)
				newObject._type = (doxygenxml.compound.LinkedTextType)_type.clone();
			newObject._definition = null;
			if (_definition != null)
				newObject._definition = (com.liquid_technologies.ltxmllib18.Element)_definition.clone();
			newObject._argsstring = null;
			if (_argsstring != null)
				newObject._argsstring = (com.liquid_technologies.ltxmllib18.Element)_argsstring.clone();
			newObject._name = null;
			if (_name != null)
				newObject._name = (com.liquid_technologies.ltxmllib18.Element)_name.clone();
			newObject._read = null;
			if (_read != null)
				newObject._read = (com.liquid_technologies.ltxmllib18.Element)_read.clone();
			newObject._write = null;
			if (_write != null)
				newObject._write = (com.liquid_technologies.ltxmllib18.Element)_write.clone();
			newObject._bitfield = null;
			if (_bitfield != null)
				newObject._bitfield = (com.liquid_technologies.ltxmllib18.Element)_bitfield.clone();
			for(int i=0; i<_reimplements.size(); i++)
				newObject._reimplements.add((doxygenxml.compound.ReimplementType)_reimplements.get(i).clone());
			for(int i=0; i<_reimplementedby.size(); i++)
				newObject._reimplementedby.add((doxygenxml.compound.ReimplementType)_reimplementedby.get(i).clone());
			for(int i=0; i<_param.size(); i++)
				newObject._param.add((doxygenxml.compound.ParamType)_param.get(i).clone());
			for(int i=0; i<_enumvalue.size(); i++)
				newObject._enumvalue.add((doxygenxml.compound.EnumvalueType)_enumvalue.get(i).clone());
			newObject._initializer = null;
			if (_initializer != null)
				newObject._initializer = (doxygenxml.compound.LinkedTextType)_initializer.clone();
			newObject._exceptions = null;
			if (_exceptions != null)
				newObject._exceptions = (doxygenxml.compound.LinkedTextType)_exceptions.clone();
			newObject._briefdescription = null;
			if (_briefdescription != null)
				newObject._briefdescription = (doxygenxml.compound.DescriptionType)_briefdescription.clone();
			newObject._detaileddescription = null;
			if (_detaileddescription != null)
				newObject._detaileddescription = (doxygenxml.compound.DescriptionType)_detaileddescription.clone();
			newObject._inbodydescription = null;
			if (_inbodydescription != null)
				newObject._inbodydescription = (doxygenxml.compound.DescriptionType)_inbodydescription.clone();
			newObject._location = null;
			if (_location != null)
				newObject._location = (doxygenxml.compound.LocationType)_location.clone();
			for(int i=0; i<_references.size(); i++)
				newObject._references.add((doxygenxml.compound.ReferenceType)_references.get(i).clone());
			for(int i=0; i<_referencedby.size(); i++)
				newObject._referencedby.add((doxygenxml.compound.ReferenceType)_referencedby.get(i).clone());
	
// ##HAND_CODED_BLOCK_START ID="Additional clone"## DO NOT MODIFY ANYTHING OUTSIDE OF THESE TAGS

// Add Additional clone code here...

// ##HAND_CODED_BLOCK_END ID="Additional clone"## DO NOT MODIFY ANYTHING OUTSIDE OF THESE TAGS

			return newObject;
		} catch (CloneNotSupportedException e) {
			// should never happen
			e.printStackTrace();
			throw new InternalError();
		}
	}

	@Override
	public String getTargetNamespace() {
		return "";
	}

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxMemberKind getKind() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidKind == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property kind is not valid. Set kindValid = true");
		return _kind;
	}
	public void setKind(doxygenxml.compound.DoxMemberKind value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_kind = value;
		_isValidKind = true;
	}
	// <summary>
	// Indicates if kind contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for kind is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxMemberKind.Define).
	// If its set to false then its made invalid, and subsequent calls to get kind
	// will raise an exception.
	// </remarks>
	public boolean isValidKind() {
		return _isValidKind;  
	}
	public void setValidKind(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidKind) {
			_kind = doxygenxml.compound.DoxMemberKind.Define;
			_isValidKind = value;
		}
	}
	protected doxygenxml.compound.DoxMemberKind _kind;
	protected boolean _isValidKind;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public java.lang.String getId() throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (_isValidId == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property id is not valid. Set idValid = true");
		return _id;  
	}
	public void setId(java.lang.String value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		// Apply whitespace rules appropriately
		value = com.liquid_technologies.ltxmllib18.WhitespaceUtils.preserve(value); 
		_isValidId = true;
		_id = value;
	}

	// <summary>
	// Indicates if id contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for id is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value ("").
	// If its set to false then its made invalid, and subsequent calls to get id
	// will raise an exception.
	// </remarks>
	public boolean isValidId() {
		return _isValidId;
	}
	public void setValidId(boolean value)  throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidId) {
			_id = "";
			_isValidId = value;
		}
	}
	protected boolean _isValidId;
	protected java.lang.String _id;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxProtectionKind getProt() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidProt == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property prot is not valid. Set protValid = true");
		return _prot;
	}
	public void setProt(doxygenxml.compound.DoxProtectionKind value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_prot = value;
		_isValidProt = true;
	}
	// <summary>
	// Indicates if prot contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for prot is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxProtectionKind.public_).
	// If its set to false then its made invalid, and subsequent calls to get prot
	// will raise an exception.
	// </remarks>
	public boolean isValidProt() {
		return _isValidProt;  
	}
	public void setValidProt(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidProt) {
			_prot = doxygenxml.compound.DoxProtectionKind.public_;
			_isValidProt = value;
		}
	}
	protected doxygenxml.compound.DoxProtectionKind _prot;
	protected boolean _isValidProt;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getStatic() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidStatic == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property static_ is not valid. Set static_Valid = true");
		return _static;
	}
	public void setStatic(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_static = value;
		_isValidStatic = true;
	}
	// <summary>
	// Indicates if static_ contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for static_ is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get static_
	// will raise an exception.
	// </remarks>
	public boolean isValidStatic() {
		return _isValidStatic;  
	}
	public void setValidStatic(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidStatic) {
			_static = doxygenxml.compound.DoxBool.Yes;
			_isValidStatic = value;
		}
	}
	protected doxygenxml.compound.DoxBool _static;
	protected boolean _isValidStatic;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getStrong() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidStrong == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property strong is not valid. Set strongValid = true");
		return _strong;
	}
	public void setStrong(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_strong = value;
		_isValidStrong = true;
	}
	// <summary>
	// Indicates if strong contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for strong is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get strong
	// will raise an exception.
	// </remarks>
	public boolean isValidStrong() {
		return _isValidStrong;  
	}
	public void setValidStrong(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidStrong) {
			_strong = doxygenxml.compound.DoxBool.Yes;
			_isValidStrong = value;
		}
	}
	protected doxygenxml.compound.DoxBool _strong;
	protected boolean _isValidStrong;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getConst() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidConst == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property const_ is not valid. Set const_Valid = true");
		return _const;
	}
	public void setConst(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_const = value;
		_isValidConst = true;
	}
	// <summary>
	// Indicates if const_ contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for const_ is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get const_
	// will raise an exception.
	// </remarks>
	public boolean isValidConst() {
		return _isValidConst;  
	}
	public void setValidConst(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidConst) {
			_const = doxygenxml.compound.DoxBool.Yes;
			_isValidConst = value;
		}
	}
	protected doxygenxml.compound.DoxBool _const;
	protected boolean _isValidConst;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getExplicit() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidExplicit == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property explicit_ is not valid. Set explicit_Valid = true");
		return _explicit;
	}
	public void setExplicit(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_explicit = value;
		_isValidExplicit = true;
	}
	// <summary>
	// Indicates if explicit_ contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for explicit_ is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get explicit_
	// will raise an exception.
	// </remarks>
	public boolean isValidExplicit() {
		return _isValidExplicit;  
	}
	public void setValidExplicit(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidExplicit) {
			_explicit = doxygenxml.compound.DoxBool.Yes;
			_isValidExplicit = value;
		}
	}
	protected doxygenxml.compound.DoxBool _explicit;
	protected boolean _isValidExplicit;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getInline() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidInline == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property inline is not valid. Set inlineValid = true");
		return _inline;
	}
	public void setInline(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_inline = value;
		_isValidInline = true;
	}
	// <summary>
	// Indicates if inline contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for inline is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get inline
	// will raise an exception.
	// </remarks>
	public boolean isValidInline() {
		return _isValidInline;  
	}
	public void setValidInline(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidInline) {
			_inline = doxygenxml.compound.DoxBool.Yes;
			_isValidInline = value;
		}
	}
	protected doxygenxml.compound.DoxBool _inline;
	protected boolean _isValidInline;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxRefQualifierKind getRefqual() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidRefqual == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property refqual is not valid. Set refqualValid = true");
		return _refqual;
	}
	public void setRefqual(doxygenxml.compound.DoxRefQualifierKind value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_refqual = value;
		_isValidRefqual = true;
	}
	// <summary>
	// Indicates if refqual contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for refqual is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxRefQualifierKind.Lvalue).
	// If its set to false then its made invalid, and subsequent calls to get refqual
	// will raise an exception.
	// </remarks>
	public boolean isValidRefqual() {
		return _isValidRefqual;  
	}
	public void setValidRefqual(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidRefqual) {
			_refqual = doxygenxml.compound.DoxRefQualifierKind.Lvalue;
			_isValidRefqual = value;
		}
	}
	protected doxygenxml.compound.DoxRefQualifierKind _refqual;
	protected boolean _isValidRefqual;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxVirtualKind getVirt() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidVirt == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property virt is not valid. Set virtValid = true");
		return _virt;
	}
	public void setVirt(doxygenxml.compound.DoxVirtualKind value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_virt = value;
		_isValidVirt = true;
	}
	// <summary>
	// Indicates if virt contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for virt is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxVirtualKind.NonMinusvirtual).
	// If its set to false then its made invalid, and subsequent calls to get virt
	// will raise an exception.
	// </remarks>
	public boolean isValidVirt() {
		return _isValidVirt;  
	}
	public void setValidVirt(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidVirt) {
			_virt = doxygenxml.compound.DoxVirtualKind.NonMinusvirtual;
			_isValidVirt = value;
		}
	}
	protected doxygenxml.compound.DoxVirtualKind _virt;
	protected boolean _isValidVirt;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getVolatile() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidVolatile == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property volatile_ is not valid. Set volatile_Valid = true");
		return _volatile;
	}
	public void setVolatile(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_volatile = value;
		_isValidVolatile = true;
	}
	// <summary>
	// Indicates if volatile_ contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for volatile_ is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get volatile_
	// will raise an exception.
	// </remarks>
	public boolean isValidVolatile() {
		return _isValidVolatile;  
	}
	public void setValidVolatile(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidVolatile) {
			_volatile = doxygenxml.compound.DoxBool.Yes;
			_isValidVolatile = value;
		}
	}
	protected doxygenxml.compound.DoxBool _volatile;
	protected boolean _isValidVolatile;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getMutable() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidMutable == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property mutable is not valid. Set mutableValid = true");
		return _mutable;
	}
	public void setMutable(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_mutable = value;
		_isValidMutable = true;
	}
	// <summary>
	// Indicates if mutable contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for mutable is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get mutable
	// will raise an exception.
	// </remarks>
	public boolean isValidMutable() {
		return _isValidMutable;  
	}
	public void setValidMutable(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidMutable) {
			_mutable = doxygenxml.compound.DoxBool.Yes;
			_isValidMutable = value;
		}
	}
	protected doxygenxml.compound.DoxBool _mutable;
	protected boolean _isValidMutable;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getNoexcept() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidNoexcept == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property noexcept is not valid. Set noexceptValid = true");
		return _noexcept;
	}
	public void setNoexcept(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_noexcept = value;
		_isValidNoexcept = true;
	}
	// <summary>
	// Indicates if noexcept contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for noexcept is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get noexcept
	// will raise an exception.
	// </remarks>
	public boolean isValidNoexcept() {
		return _isValidNoexcept;  
	}
	public void setValidNoexcept(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidNoexcept) {
			_noexcept = doxygenxml.compound.DoxBool.Yes;
			_isValidNoexcept = value;
		}
	}
	protected doxygenxml.compound.DoxBool _noexcept;
	protected boolean _isValidNoexcept;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getConstexpr() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidConstexpr == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property constexpr is not valid. Set constexprValid = true");
		return _constexpr;
	}
	public void setConstexpr(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_constexpr = value;
		_isValidConstexpr = true;
	}
	// <summary>
	// Indicates if constexpr contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for constexpr is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get constexpr
	// will raise an exception.
	// </remarks>
	public boolean isValidConstexpr() {
		return _isValidConstexpr;  
	}
	public void setValidConstexpr(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidConstexpr) {
			_constexpr = doxygenxml.compound.DoxBool.Yes;
			_isValidConstexpr = value;
		}
	}
	protected doxygenxml.compound.DoxBool _constexpr;
	protected boolean _isValidConstexpr;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getReadable() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidReadable == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property readable is not valid. Set readableValid = true");
		return _readable;
	}
	public void setReadable(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_readable = value;
		_isValidReadable = true;
	}
	// <summary>
	// Indicates if readable contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for readable is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get readable
	// will raise an exception.
	// </remarks>
	public boolean isValidReadable() {
		return _isValidReadable;  
	}
	public void setValidReadable(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidReadable) {
			_readable = doxygenxml.compound.DoxBool.Yes;
			_isValidReadable = value;
		}
	}
	protected doxygenxml.compound.DoxBool _readable;
	protected boolean _isValidReadable;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getWritable() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidWritable == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property writable is not valid. Set writableValid = true");
		return _writable;
	}
	public void setWritable(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_writable = value;
		_isValidWritable = true;
	}
	// <summary>
	// Indicates if writable contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for writable is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get writable
	// will raise an exception.
	// </remarks>
	public boolean isValidWritable() {
		return _isValidWritable;  
	}
	public void setValidWritable(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidWritable) {
			_writable = doxygenxml.compound.DoxBool.Yes;
			_isValidWritable = value;
		}
	}
	protected doxygenxml.compound.DoxBool _writable;
	protected boolean _isValidWritable;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getInitonly() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidInitonly == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property initonly is not valid. Set initonlyValid = true");
		return _initonly;
	}
	public void setInitonly(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_initonly = value;
		_isValidInitonly = true;
	}
	// <summary>
	// Indicates if initonly contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for initonly is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get initonly
	// will raise an exception.
	// </remarks>
	public boolean isValidInitonly() {
		return _isValidInitonly;  
	}
	public void setValidInitonly(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidInitonly) {
			_initonly = doxygenxml.compound.DoxBool.Yes;
			_isValidInitonly = value;
		}
	}
	protected doxygenxml.compound.DoxBool _initonly;
	protected boolean _isValidInitonly;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getSettable() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidSettable == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property settable is not valid. Set settableValid = true");
		return _settable;
	}
	public void setSettable(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_settable = value;
		_isValidSettable = true;
	}
	// <summary>
	// Indicates if settable contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for settable is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get settable
	// will raise an exception.
	// </remarks>
	public boolean isValidSettable() {
		return _isValidSettable;  
	}
	public void setValidSettable(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidSettable) {
			_settable = doxygenxml.compound.DoxBool.Yes;
			_isValidSettable = value;
		}
	}
	protected doxygenxml.compound.DoxBool _settable;
	protected boolean _isValidSettable;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getPrivatesettable() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidPrivatesettable == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property privatesettable is not valid. Set privatesettableValid = true");
		return _privatesettable;
	}
	public void setPrivatesettable(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_privatesettable = value;
		_isValidPrivatesettable = true;
	}
	// <summary>
	// Indicates if privatesettable contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for privatesettable is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get privatesettable
	// will raise an exception.
	// </remarks>
	public boolean isValidPrivatesettable() {
		return _isValidPrivatesettable;  
	}
	public void setValidPrivatesettable(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidPrivatesettable) {
			_privatesettable = doxygenxml.compound.DoxBool.Yes;
			_isValidPrivatesettable = value;
		}
	}
	protected doxygenxml.compound.DoxBool _privatesettable;
	protected boolean _isValidPrivatesettable;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getProtectedsettable() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidProtectedsettable == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property protectedsettable is not valid. Set protectedsettableValid = true");
		return _protectedsettable;
	}
	public void setProtectedsettable(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_protectedsettable = value;
		_isValidProtectedsettable = true;
	}
	// <summary>
	// Indicates if protectedsettable contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for protectedsettable is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get protectedsettable
	// will raise an exception.
	// </remarks>
	public boolean isValidProtectedsettable() {
		return _isValidProtectedsettable;  
	}
	public void setValidProtectedsettable(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidProtectedsettable) {
			_protectedsettable = doxygenxml.compound.DoxBool.Yes;
			_isValidProtectedsettable = value;
		}
	}
	protected doxygenxml.compound.DoxBool _protectedsettable;
	protected boolean _isValidProtectedsettable;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getGettable() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidGettable == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property gettable is not valid. Set gettableValid = true");
		return _gettable;
	}
	public void setGettable(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_gettable = value;
		_isValidGettable = true;
	}
	// <summary>
	// Indicates if gettable contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for gettable is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get gettable
	// will raise an exception.
	// </remarks>
	public boolean isValidGettable() {
		return _isValidGettable;  
	}
	public void setValidGettable(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidGettable) {
			_gettable = doxygenxml.compound.DoxBool.Yes;
			_isValidGettable = value;
		}
	}
	protected doxygenxml.compound.DoxBool _gettable;
	protected boolean _isValidGettable;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getPrivategettable() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidPrivategettable == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property privategettable is not valid. Set privategettableValid = true");
		return _privategettable;
	}
	public void setPrivategettable(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_privategettable = value;
		_isValidPrivategettable = true;
	}
	// <summary>
	// Indicates if privategettable contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for privategettable is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get privategettable
	// will raise an exception.
	// </remarks>
	public boolean isValidPrivategettable() {
		return _isValidPrivategettable;  
	}
	public void setValidPrivategettable(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidPrivategettable) {
			_privategettable = doxygenxml.compound.DoxBool.Yes;
			_isValidPrivategettable = value;
		}
	}
	protected doxygenxml.compound.DoxBool _privategettable;
	protected boolean _isValidPrivategettable;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getProtectedgettable() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidProtectedgettable == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property protectedgettable is not valid. Set protectedgettableValid = true");
		return _protectedgettable;
	}
	public void setProtectedgettable(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_protectedgettable = value;
		_isValidProtectedgettable = true;
	}
	// <summary>
	// Indicates if protectedgettable contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for protectedgettable is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get protectedgettable
	// will raise an exception.
	// </remarks>
	public boolean isValidProtectedgettable() {
		return _isValidProtectedgettable;  
	}
	public void setValidProtectedgettable(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidProtectedgettable) {
			_protectedgettable = doxygenxml.compound.DoxBool.Yes;
			_isValidProtectedgettable = value;
		}
	}
	protected doxygenxml.compound.DoxBool _protectedgettable;
	protected boolean _isValidProtectedgettable;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getFinal() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidFinal == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property final is not valid. Set finalValid = true");
		return _final;
	}
	public void setFinal(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_final = value;
		_isValidFinal = true;
	}
	// <summary>
	// Indicates if final contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for final is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get final
	// will raise an exception.
	// </remarks>
	public boolean isValidFinal() {
		return _isValidFinal;  
	}
	public void setValidFinal(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidFinal) {
			_final = doxygenxml.compound.DoxBool.Yes;
			_isValidFinal = value;
		}
	}
	protected doxygenxml.compound.DoxBool _final;
	protected boolean _isValidFinal;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getSealed() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidSealed == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property sealed_ is not valid. Set sealed_Valid = true");
		return _sealed;
	}
	public void setSealed(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_sealed = value;
		_isValidSealed = true;
	}
	// <summary>
	// Indicates if sealed_ contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for sealed_ is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get sealed_
	// will raise an exception.
	// </remarks>
	public boolean isValidSealed() {
		return _isValidSealed;  
	}
	public void setValidSealed(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidSealed) {
			_sealed = doxygenxml.compound.DoxBool.Yes;
			_isValidSealed = value;
		}
	}
	protected doxygenxml.compound.DoxBool _sealed;
	protected boolean _isValidSealed;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getNew() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidNew == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property new_ is not valid. Set new_Valid = true");
		return _new;
	}
	public void setNew(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_new = value;
		_isValidNew = true;
	}
	// <summary>
	// Indicates if new_ contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for new_ is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get new_
	// will raise an exception.
	// </remarks>
	public boolean isValidNew() {
		return _isValidNew;  
	}
	public void setValidNew(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidNew) {
			_new = doxygenxml.compound.DoxBool.Yes;
			_isValidNew = value;
		}
	}
	protected doxygenxml.compound.DoxBool _new;
	protected boolean _isValidNew;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getAdd() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidAdd == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property add is not valid. Set addValid = true");
		return _add;
	}
	public void setAdd(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_add = value;
		_isValidAdd = true;
	}
	// <summary>
	// Indicates if add contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for add is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get add
	// will raise an exception.
	// </remarks>
	public boolean isValidAdd() {
		return _isValidAdd;  
	}
	public void setValidAdd(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidAdd) {
			_add = doxygenxml.compound.DoxBool.Yes;
			_isValidAdd = value;
		}
	}
	protected doxygenxml.compound.DoxBool _add;
	protected boolean _isValidAdd;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getRemove() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidRemove == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property remove is not valid. Set removeValid = true");
		return _remove;
	}
	public void setRemove(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_remove = value;
		_isValidRemove = true;
	}
	// <summary>
	// Indicates if remove contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for remove is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get remove
	// will raise an exception.
	// </remarks>
	public boolean isValidRemove() {
		return _isValidRemove;  
	}
	public void setValidRemove(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidRemove) {
			_remove = doxygenxml.compound.DoxBool.Yes;
			_isValidRemove = value;
		}
	}
	protected doxygenxml.compound.DoxBool _remove;
	protected boolean _isValidRemove;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getRaise() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidRaise == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property raise is not valid. Set raiseValid = true");
		return _raise;
	}
	public void setRaise(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_raise = value;
		_isValidRaise = true;
	}
	// <summary>
	// Indicates if raise contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for raise is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get raise
	// will raise an exception.
	// </remarks>
	public boolean isValidRaise() {
		return _isValidRaise;  
	}
	public void setValidRaise(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidRaise) {
			_raise = doxygenxml.compound.DoxBool.Yes;
			_isValidRaise = value;
		}
	}
	protected doxygenxml.compound.DoxBool _raise;
	protected boolean _isValidRaise;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getOptional() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidOptional == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property optional is not valid. Set optionalValid = true");
		return _optional;
	}
	public void setOptional(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_optional = value;
		_isValidOptional = true;
	}
	// <summary>
	// Indicates if optional contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for optional is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get optional
	// will raise an exception.
	// </remarks>
	public boolean isValidOptional() {
		return _isValidOptional;  
	}
	public void setValidOptional(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidOptional) {
			_optional = doxygenxml.compound.DoxBool.Yes;
			_isValidOptional = value;
		}
	}
	protected doxygenxml.compound.DoxBool _optional;
	protected boolean _isValidOptional;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getRequired() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidRequired == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property required is not valid. Set requiredValid = true");
		return _required;
	}
	public void setRequired(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_required = value;
		_isValidRequired = true;
	}
	// <summary>
	// Indicates if required contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for required is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get required
	// will raise an exception.
	// </remarks>
	public boolean isValidRequired() {
		return _isValidRequired;  
	}
	public void setValidRequired(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidRequired) {
			_required = doxygenxml.compound.DoxBool.Yes;
			_isValidRequired = value;
		}
	}
	protected doxygenxml.compound.DoxBool _required;
	protected boolean _isValidRequired;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxAccessor getAccessor() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidAccessor == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property accessor is not valid. Set accessorValid = true");
		return _accessor;
	}
	public void setAccessor(doxygenxml.compound.DoxAccessor value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_accessor = value;
		_isValidAccessor = true;
	}
	// <summary>
	// Indicates if accessor contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for accessor is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxAccessor.Retain).
	// If its set to false then its made invalid, and subsequent calls to get accessor
	// will raise an exception.
	// </remarks>
	public boolean isValidAccessor() {
		return _isValidAccessor;  
	}
	public void setValidAccessor(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidAccessor) {
			_accessor = doxygenxml.compound.DoxAccessor.Retain;
			_isValidAccessor = value;
		}
	}
	protected doxygenxml.compound.DoxAccessor _accessor;
	protected boolean _isValidAccessor;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getAttribute() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidAttribute == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property attribute is not valid. Set attributeValid = true");
		return _attribute;
	}
	public void setAttribute(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_attribute = value;
		_isValidAttribute = true;
	}
	// <summary>
	// Indicates if attribute contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for attribute is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get attribute
	// will raise an exception.
	// </remarks>
	public boolean isValidAttribute() {
		return _isValidAttribute;  
	}
	public void setValidAttribute(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidAttribute) {
			_attribute = doxygenxml.compound.DoxBool.Yes;
			_isValidAttribute = value;
		}
	}
	protected doxygenxml.compound.DoxBool _attribute;
	protected boolean _isValidAttribute;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getProperty() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidProperty == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property property is not valid. Set propertyValid = true");
		return _property;
	}
	public void setProperty(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_property = value;
		_isValidProperty = true;
	}
	// <summary>
	// Indicates if property contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for property is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get property
	// will raise an exception.
	// </remarks>
	public boolean isValidProperty() {
		return _isValidProperty;  
	}
	public void setValidProperty(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidProperty) {
			_property = doxygenxml.compound.DoxBool.Yes;
			_isValidProperty = value;
		}
	}
	protected doxygenxml.compound.DoxBool _property;
	protected boolean _isValidProperty;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getReadonly() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidReadonly == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property readonly_ is not valid. Set readonly_Valid = true");
		return _readonly;
	}
	public void setReadonly(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_readonly = value;
		_isValidReadonly = true;
	}
	// <summary>
	// Indicates if readonly_ contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for readonly_ is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get readonly_
	// will raise an exception.
	// </remarks>
	public boolean isValidReadonly() {
		return _isValidReadonly;  
	}
	public void setValidReadonly(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidReadonly) {
			_readonly = doxygenxml.compound.DoxBool.Yes;
			_isValidReadonly = value;
		}
	}
	protected doxygenxml.compound.DoxBool _readonly;
	protected boolean _isValidReadonly;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getBound() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidBound == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property bound is not valid. Set boundValid = true");
		return _bound;
	}
	public void setBound(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_bound = value;
		_isValidBound = true;
	}
	// <summary>
	// Indicates if bound contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for bound is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get bound
	// will raise an exception.
	// </remarks>
	public boolean isValidBound() {
		return _isValidBound;  
	}
	public void setValidBound(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidBound) {
			_bound = doxygenxml.compound.DoxBool.Yes;
			_isValidBound = value;
		}
	}
	protected doxygenxml.compound.DoxBool _bound;
	protected boolean _isValidBound;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getRemovable() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidRemovable == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property removable is not valid. Set removableValid = true");
		return _removable;
	}
	public void setRemovable(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_removable = value;
		_isValidRemovable = true;
	}
	// <summary>
	// Indicates if removable contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for removable is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get removable
	// will raise an exception.
	// </remarks>
	public boolean isValidRemovable() {
		return _isValidRemovable;  
	}
	public void setValidRemovable(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidRemovable) {
			_removable = doxygenxml.compound.DoxBool.Yes;
			_isValidRemovable = value;
		}
	}
	protected doxygenxml.compound.DoxBool _removable;
	protected boolean _isValidRemovable;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getConstrained() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidConstrained == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property constrained is not valid. Set constrainedValid = true");
		return _constrained;
	}
	public void setConstrained(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_constrained = value;
		_isValidConstrained = true;
	}
	// <summary>
	// Indicates if constrained contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for constrained is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get constrained
	// will raise an exception.
	// </remarks>
	public boolean isValidConstrained() {
		return _isValidConstrained;  
	}
	public void setValidConstrained(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidConstrained) {
			_constrained = doxygenxml.compound.DoxBool.Yes;
			_isValidConstrained = value;
		}
	}
	protected doxygenxml.compound.DoxBool _constrained;
	protected boolean _isValidConstrained;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getTransient() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidTransient == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property transient is not valid. Set transientValid = true");
		return _transient;
	}
	public void setTransient(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_transient = value;
		_isValidTransient = true;
	}
	// <summary>
	// Indicates if transient contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for transient is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get transient
	// will raise an exception.
	// </remarks>
	public boolean isValidTransient() {
		return _isValidTransient;  
	}
	public void setValidTransient(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidTransient) {
			_transient = doxygenxml.compound.DoxBool.Yes;
			_isValidTransient = value;
		}
	}
	protected doxygenxml.compound.DoxBool _transient;
	protected boolean _isValidTransient;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getMaybevoid() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidMaybevoid == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property maybevoid is not valid. Set maybevoidValid = true");
		return _maybevoid;
	}
	public void setMaybevoid(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_maybevoid = value;
		_isValidMaybevoid = true;
	}
	// <summary>
	// Indicates if maybevoid contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for maybevoid is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get maybevoid
	// will raise an exception.
	// </remarks>
	public boolean isValidMaybevoid() {
		return _isValidMaybevoid;  
	}
	public void setValidMaybevoid(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidMaybevoid) {
			_maybevoid = doxygenxml.compound.DoxBool.Yes;
			_isValidMaybevoid = value;
		}
	}
	protected doxygenxml.compound.DoxBool _maybevoid;
	protected boolean _isValidMaybevoid;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getMaybedefault() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidMaybedefault == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property maybedefault is not valid. Set maybedefaultValid = true");
		return _maybedefault;
	}
	public void setMaybedefault(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_maybedefault = value;
		_isValidMaybedefault = true;
	}
	// <summary>
	// Indicates if maybedefault contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for maybedefault is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get maybedefault
	// will raise an exception.
	// </remarks>
	public boolean isValidMaybedefault() {
		return _isValidMaybedefault;  
	}
	public void setValidMaybedefault(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidMaybedefault) {
			_maybedefault = doxygenxml.compound.DoxBool.Yes;
			_isValidMaybedefault = value;
		}
	}
	protected doxygenxml.compound.DoxBool _maybedefault;
	protected boolean _isValidMaybedefault;

	// <summary>
	// Represents an optional Attribute in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Attribute in the XML.
	// It is optional, initially it is not valid.
	// </remarks>
	public doxygenxml.compound.DoxBool getMaybeambiguous() throws com.liquid_technologies.ltxmllib18.exceptions.LtException {
		if (_isValidMaybeambiguous == false)
			throw new com.liquid_technologies.ltxmllib18.exceptions.LtInvalidStateException("The Property maybeambiguous is not valid. Set maybeambiguousValid = true");
		return _maybeambiguous;
	}
	public void setMaybeambiguous(doxygenxml.compound.DoxBool value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		_maybeambiguous = value;
		_isValidMaybeambiguous = true;
	}
	// <summary>
	// Indicates if maybeambiguous contains a valid value.
	// </summary>
	// <remarks>
	// true if the value for maybeambiguous is valid, false if not.
	// If this is set to true then the property is considered valid, and assigned its
	// default value (doxygenxml.compound.DoxBool.Yes).
	// If its set to false then its made invalid, and subsequent calls to get maybeambiguous
	// will raise an exception.
	// </remarks>
	public boolean isValidMaybeambiguous() {
		return _isValidMaybeambiguous;  
	}
	public void setValidMaybeambiguous(boolean value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != _isValidMaybeambiguous) {
			_maybeambiguous = doxygenxml.compound.DoxBool.Yes;
			_isValidMaybeambiguous = value;
		}
	}
	protected doxygenxml.compound.DoxBool _maybeambiguous;
	protected boolean _isValidMaybeambiguous;

	// <summary>
	// Represents an optional Element in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Element in the XML.
	// It is optional, initially it is null.

	// </remarks>
	public doxygenxml.compound.TemplateparamlistType getTemplateparamlist() {
		return _templateparamlist;  
	}
	public void setTemplateparamlist(doxygenxml.compound.TemplateparamlistType value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value == null)
			_templateparamlist = null;
		else {
			setElementName(value.getBase(), "templateparamlist");
			_templateparamlist = value; 
		}
	}
	protected doxygenxml.compound.TemplateparamlistType _templateparamlist;

	// <summary>
	// Represents an optional Element in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Element in the XML.
	// It is optional, initially it is null.

	// </remarks>
	public doxygenxml.compound.LinkedTextType getType() {
		return _type;  
	}
	public void setType(doxygenxml.compound.LinkedTextType value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value == null)
			_type = null;
		else {
			setElementName(value.getBase(), "type");
			_type = value; 
		}
	}
	protected doxygenxml.compound.LinkedTextType _type;

	// <summary>
	// Represents an optional untyped element in the XML document
	// </summary>
	// <remarks>
	// It is optional, initially it is null.

	// </remarks>
	public com.liquid_technologies.ltxmllib18.Element getDefinition() {
		return _definition;  
	}
	public void setDefinition(com.liquid_technologies.ltxmllib18.Element value)  throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != null)
			testNamespace(value.getNamespace(), "##any", "");
		_definition = value; 
	}
	protected com.liquid_technologies.ltxmllib18.Element _definition;

	// <summary>
	// Represents an optional untyped element in the XML document
	// </summary>
	// <remarks>
	// It is optional, initially it is null.

	// </remarks>
	public com.liquid_technologies.ltxmllib18.Element getArgsstring() {
		return _argsstring;  
	}
	public void setArgsstring(com.liquid_technologies.ltxmllib18.Element value)  throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != null)
			testNamespace(value.getNamespace(), "##any", "");
		_argsstring = value; 
	}
	protected com.liquid_technologies.ltxmllib18.Element _argsstring;

	// <summary>
	// Represents an optional untyped element in the XML document
	// </summary>
	// <remarks>
	// It is optional, initially it is null.

	// </remarks>
	public com.liquid_technologies.ltxmllib18.Element getName() {
		return _name;  
	}
	public void setName(com.liquid_technologies.ltxmllib18.Element value)  throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != null)
			testNamespace(value.getNamespace(), "##any", "");
		_name = value; 
	}
	protected com.liquid_technologies.ltxmllib18.Element _name;

	// <summary>
	// Represents an optional untyped element in the XML document
	// </summary>
	// <remarks>
	// It is optional, initially it is null.

	// </remarks>
	public com.liquid_technologies.ltxmllib18.Element getRead() {
		return _read;  
	}
	public void setRead(com.liquid_technologies.ltxmllib18.Element value)  throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != null)
			testNamespace(value.getNamespace(), "##any", "");
		_read = value; 
	}
	protected com.liquid_technologies.ltxmllib18.Element _read;

	// <summary>
	// Represents an optional untyped element in the XML document
	// </summary>
	// <remarks>
	// It is optional, initially it is null.

	// </remarks>
	public com.liquid_technologies.ltxmllib18.Element getWrite() {
		return _write;  
	}
	public void setWrite(com.liquid_technologies.ltxmllib18.Element value)  throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != null)
			testNamespace(value.getNamespace(), "##any", "");
		_write = value; 
	}
	protected com.liquid_technologies.ltxmllib18.Element _write;

	// <summary>
	// Represents an optional untyped element in the XML document
	// </summary>
	// <remarks>
	// It is optional, initially it is null.

	// </remarks>
	public com.liquid_technologies.ltxmllib18.Element getBitfield() {
		return _bitfield;  
	}
	public void setBitfield(com.liquid_technologies.ltxmllib18.Element value)  throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value != null)
			testNamespace(value.getNamespace(), "##any", "");
		_bitfield = value; 
	}
	protected com.liquid_technologies.ltxmllib18.Element _bitfield;

	// <summary>
	// A collection of reimplementss
	// </summary>
	// <remarks>
	// This property is represented as an Element in the XML.
	// This collection may contain 0 to Many objects.
	// </remarks>
	public doxygenxml.compound.XmlObjectCollection<doxygenxml.compound.ReimplementType> getReimplements() {
		return _reimplements; 
	}
	protected doxygenxml.compound.XmlObjectCollection<doxygenxml.compound.ReimplementType> _reimplements;


	// <summary>
	// A collection of reimplementedbys
	// </summary>
	// <remarks>
	// This property is represented as an Element in the XML.
	// This collection may contain 0 to Many objects.
	// </remarks>
	public doxygenxml.compound.XmlObjectCollection<doxygenxml.compound.ReimplementType> getReimplementedby() {
		return _reimplementedby; 
	}
	protected doxygenxml.compound.XmlObjectCollection<doxygenxml.compound.ReimplementType> _reimplementedby;


	// <summary>
	// A collection of params
	// </summary>
	// <remarks>
	// This property is represented as an Element in the XML.
	// This collection may contain 0 to Many objects.
	// </remarks>
	public doxygenxml.compound.XmlObjectCollection<doxygenxml.compound.ParamType> getParam() {
		return _param; 
	}
	protected doxygenxml.compound.XmlObjectCollection<doxygenxml.compound.ParamType> _param;


	// <summary>
	// A collection of enumvalues
	// </summary>
	// <remarks>
	// This property is represented as an Element in the XML.
	// This collection may contain 0 to Many objects.
	// </remarks>
	public doxygenxml.compound.XmlObjectCollection<doxygenxml.compound.EnumvalueType> getEnumvalue() {
		return _enumvalue; 
	}
	protected doxygenxml.compound.XmlObjectCollection<doxygenxml.compound.EnumvalueType> _enumvalue;


	// <summary>
	// Represents an optional Element in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Element in the XML.
	// It is optional, initially it is null.

	// </remarks>
	public doxygenxml.compound.LinkedTextType getInitializer() {
		return _initializer;  
	}
	public void setInitializer(doxygenxml.compound.LinkedTextType value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value == null)
			_initializer = null;
		else {
			setElementName(value.getBase(), "initializer");
			_initializer = value; 
		}
	}
	protected doxygenxml.compound.LinkedTextType _initializer;

	// <summary>
	// Represents an optional Element in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Element in the XML.
	// It is optional, initially it is null.

	// </remarks>
	public doxygenxml.compound.LinkedTextType getExceptions() {
		return _exceptions;  
	}
	public void setExceptions(doxygenxml.compound.LinkedTextType value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value == null)
			_exceptions = null;
		else {
			setElementName(value.getBase(), "exceptions");
			_exceptions = value; 
		}
	}
	protected doxygenxml.compound.LinkedTextType _exceptions;

	// <summary>
	// Represents an optional Element in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Element in the XML.
	// It is optional, initially it is null.

	// </remarks>
	public doxygenxml.compound.DescriptionType getBriefdescription() {
		return _briefdescription;  
	}
	public void setBriefdescription(doxygenxml.compound.DescriptionType value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value == null)
			_briefdescription = null;
		else {
			setElementName(value.getBase(), "briefdescription");
			_briefdescription = value; 
		}
	}
	protected doxygenxml.compound.DescriptionType _briefdescription;

	// <summary>
	// Represents an optional Element in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Element in the XML.
	// It is optional, initially it is null.

	// </remarks>
	public doxygenxml.compound.DescriptionType getDetaileddescription() {
		return _detaileddescription;  
	}
	public void setDetaileddescription(doxygenxml.compound.DescriptionType value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value == null)
			_detaileddescription = null;
		else {
			setElementName(value.getBase(), "detaileddescription");
			_detaileddescription = value; 
		}
	}
	protected doxygenxml.compound.DescriptionType _detaileddescription;

	// <summary>
	// Represents an optional Element in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Element in the XML.
	// It is optional, initially it is null.

	// </remarks>
	public doxygenxml.compound.DescriptionType getInbodydescription() {
		return _inbodydescription;  
	}
	public void setInbodydescription(doxygenxml.compound.DescriptionType value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		if (value == null)
			_inbodydescription = null;
		else {
			setElementName(value.getBase(), "inbodydescription");
			_inbodydescription = value; 
		}
	}
	protected doxygenxml.compound.DescriptionType _inbodydescription;

	// <summary>
	// Represents a mandatory Element in the XML document
	// </summary>
	// <remarks>
	// This property is represented as an Element in the XML.
	// It is mandatory and therefore must be populated within the XML.
	// If this property is set, then the object will be COPIED. If the property is set to null an exception is raised.
	// </remarks>
	public doxygenxml.compound.LocationType getLocation() {
		return _location;
	}
	public void setLocation(doxygenxml.compound.LocationType value) throws com.liquid_technologies.ltxmllib18.exceptions.LtException { 
		throw_IfPropertyIsNull(value, "location");
		if (value != null)
			setElementName(value.getBase(), "location");
//		throw_IfElementNameDiffers(value, "location");
		_location = value;
	}
	protected doxygenxml.compound.LocationType _location;


	// <summary>
	// A collection of referencess
	// </summary>
	// <remarks>
	// This property is represented as an Element in the XML.
	// This collection may contain 0 to Many objects.
	// </remarks>
	public doxygenxml.compound.XmlObjectCollection<doxygenxml.compound.ReferenceType> getReferences() {
		return _references; 
	}
	protected doxygenxml.compound.XmlObjectCollection<doxygenxml.compound.ReferenceType> _references;


	// <summary>
	// A collection of referencedbys
	// </summary>
	// <remarks>
	// This property is represented as an Element in the XML.
	// This collection may contain 0 to Many objects.
	// </remarks>
	public doxygenxml.compound.XmlObjectCollection<doxygenxml.compound.ReferenceType> getReferencedby() {
		return _referencedby; 
	}
	protected doxygenxml.compound.XmlObjectCollection<doxygenxml.compound.ReferenceType> _referencedby;


	@Override
	public String getNamespace() {
		return "";
	}	

	@Override
	public com.liquid_technologies.ltxmllib18.XmlObjectBase getBase() {
		return this;
	}
	protected void onEvent(com.liquid_technologies.ltxmllib18.XmlObjectBase msgSource, int msgType, Object data) {
		if (msgType == CollectionChangeEvent) {
		}
	}

	private static com.liquid_technologies.ltxmllib18.ParentElementInfo __parentElementInfo = null;
	private static com.liquid_technologies.ltxmllib18.ElementInfo[] __elementInfo = null;
	private static com.liquid_technologies.ltxmllib18.AttributeInfo[] __attributeInfo = null;
		
	protected com.liquid_technologies.ltxmllib18.ParentElementInfo getClassInfo() throws Exception {
		if (__parentElementInfo == null) {
			__parentElementInfo = new com.liquid_technologies.ltxmllib18.ParentElementInfo(	
																	com.liquid_technologies.ltxmllib18.XmlObjectBase.XmlElementGroupType.SEQUENCE,
																	com.liquid_technologies.ltxmllib18.XmlObjectBase.XmlElementType.ELEMENT, "memberdefType", "", true, false,
																	null, null, com.liquid_technologies.ltxmllib18.Conversions.ConversionType.TYPE_NONE, null, false);
		}
		return __parentElementInfo;
	}

	protected com.liquid_technologies.ltxmllib18.ElementInfo[] getClassElementInfo() throws Exception {
		if (__elementInfo == null) {
			__elementInfo = new com.liquid_technologies.ltxmllib18.ElementInfo[] {
				 new com.liquid_technologies.ltxmllib18.data.ElementInfoSeqClsOpt("templateparamlist", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getTemplateparamlist"), findSetterMethod("doxygenxml.compound.MemberdefType", "setTemplateparamlist", "doxygenxml.compound.TemplateparamlistType"), com.liquid_technologies.ltxmllib18.XmlObjectBase.XmlElementType.ELEMENT, doxygenxml.compound.TemplateparamlistType.class)
				,new com.liquid_technologies.ltxmllib18.data.ElementInfoSeqClsOpt("type", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getType"), findSetterMethod("doxygenxml.compound.MemberdefType", "setType", "doxygenxml.compound.LinkedTextType"), com.liquid_technologies.ltxmllib18.XmlObjectBase.XmlElementType.ELEMENT, doxygenxml.compound.LinkedTextType.class)
				,new com.liquid_technologies.ltxmllib18.data.ElementInfoSeqUntpdOpt("definition", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getDefinition"), findSetterMethod("doxygenxml.compound.MemberdefType", "setDefinition", "com.liquid_technologies.ltxmllib18.Element"), "##any", "")
				,new com.liquid_technologies.ltxmllib18.data.ElementInfoSeqUntpdOpt("argsstring", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getArgsstring"), findSetterMethod("doxygenxml.compound.MemberdefType", "setArgsstring", "com.liquid_technologies.ltxmllib18.Element"), "##any", "")
				,new com.liquid_technologies.ltxmllib18.data.ElementInfoSeqUntpdOpt("name", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getName"), findSetterMethod("doxygenxml.compound.MemberdefType", "setName", "com.liquid_technologies.ltxmllib18.Element"), "##any", "")
				,new com.liquid_technologies.ltxmllib18.data.ElementInfoSeqUntpdOpt("read", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getRead"), findSetterMethod("doxygenxml.compound.MemberdefType", "setRead", "com.liquid_technologies.ltxmllib18.Element"), "##any", "")
				,new com.liquid_technologies.ltxmllib18.data.ElementInfoSeqUntpdOpt("write", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getWrite"), findSetterMethod("doxygenxml.compound.MemberdefType", "setWrite", "com.liquid_technologies.ltxmllib18.Element"), "##any", "")
				,new com.liquid_technologies.ltxmllib18.data.ElementInfoSeqUntpdOpt("bitfield", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getBitfield"), findSetterMethod("doxygenxml.compound.MemberdefType", "setBitfield", "com.liquid_technologies.ltxmllib18.Element"), "##any", "")
				,new com.liquid_technologies.ltxmllib18.data.ElementInfoSeqClsCol("reimplements", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getReimplements"), com.liquid_technologies.ltxmllib18.XmlObjectBase.XmlElementType.ELEMENT)
				,new com.liquid_technologies.ltxmllib18.data.ElementInfoSeqClsCol("reimplementedby", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getReimplementedby"), com.liquid_technologies.ltxmllib18.XmlObjectBase.XmlElementType.ELEMENT)
				,new com.liquid_technologies.ltxmllib18.data.ElementInfoSeqClsCol("param", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getParam"), com.liquid_technologies.ltxmllib18.XmlObjectBase.XmlElementType.ELEMENT)
				,new com.liquid_technologies.ltxmllib18.data.ElementInfoSeqClsCol("enumvalue", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getEnumvalue"), com.liquid_technologies.ltxmllib18.XmlObjectBase.XmlElementType.ELEMENT)
				,new com.liquid_technologies.ltxmllib18.data.ElementInfoSeqClsOpt("initializer", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getInitializer"), findSetterMethod("doxygenxml.compound.MemberdefType", "setInitializer", "doxygenxml.compound.LinkedTextType"), com.liquid_technologies.ltxmllib18.XmlObjectBase.XmlElementType.ELEMENT, doxygenxml.compound.LinkedTextType.class)
				,new com.liquid_technologies.ltxmllib18.data.ElementInfoSeqClsOpt("exceptions", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getExceptions"), findSetterMethod("doxygenxml.compound.MemberdefType", "setExceptions", "doxygenxml.compound.LinkedTextType"), com.liquid_technologies.ltxmllib18.XmlObjectBase.XmlElementType.ELEMENT, doxygenxml.compound.LinkedTextType.class)
				,new com.liquid_technologies.ltxmllib18.data.ElementInfoSeqClsOpt("briefdescription", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getBriefdescription"), findSetterMethod("doxygenxml.compound.MemberdefType", "setBriefdescription", "doxygenxml.compound.DescriptionType"), com.liquid_technologies.ltxmllib18.XmlObjectBase.XmlElementType.ELEMENT, doxygenxml.compound.DescriptionType.class)
				,new com.liquid_technologies.ltxmllib18.data.ElementInfoSeqClsOpt("detaileddescription", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getDetaileddescription"), findSetterMethod("doxygenxml.compound.MemberdefType", "setDetaileddescription", "doxygenxml.compound.DescriptionType"), com.liquid_technologies.ltxmllib18.XmlObjectBase.XmlElementType.ELEMENT, doxygenxml.compound.DescriptionType.class)
				,new com.liquid_technologies.ltxmllib18.data.ElementInfoSeqClsOpt("inbodydescription", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getInbodydescription"), findSetterMethod("doxygenxml.compound.MemberdefType", "setInbodydescription", "doxygenxml.compound.DescriptionType"), com.liquid_technologies.ltxmllib18.XmlObjectBase.XmlElementType.ELEMENT, doxygenxml.compound.DescriptionType.class)
				,new com.liquid_technologies.ltxmllib18.data.ElementInfoSeqClsMnd("location", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getLocation"), findSetterMethod("doxygenxml.compound.MemberdefType", "setLocation", "doxygenxml.compound.LocationType"), com.liquid_technologies.ltxmllib18.XmlObjectBase.XmlElementType.ELEMENT, doxygenxml.compound.LocationType.class, false)
				,new com.liquid_technologies.ltxmllib18.data.ElementInfoSeqClsCol("references", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getReferences"), com.liquid_technologies.ltxmllib18.XmlObjectBase.XmlElementType.ELEMENT)
				,new com.liquid_technologies.ltxmllib18.data.ElementInfoSeqClsCol("referencedby", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getReferencedby"), com.liquid_technologies.ltxmllib18.XmlObjectBase.XmlElementType.ELEMENT)
			};
		}
		return __elementInfo;
	}

	protected com.liquid_technologies.ltxmllib18.AttributeInfo[] getClassAttributeInfo() throws Exception {
		if (__attributeInfo==null) {
			__attributeInfo = new com.liquid_technologies.ltxmllib18.AttributeInfo[] {
				 new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("kind", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getKind"), findSetterMethod("doxygenxml.compound.MemberdefType", "setKind", "doxygenxml.compound.DoxMemberKind"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidKind"), getEnumFromString("doxygenxml.compound.DoxMemberKind", "DoxMemberKind"), getEnumToString("doxygenxml.compound.DoxMemberKind", "DoxMemberKind"), null)
				,new com.liquid_technologies.ltxmllib18.AttributeInfoPrimitive("id", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getId"), findSetterMethod("doxygenxml.compound.MemberdefType", "setId", "java.lang.String"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidId"), com.liquid_technologies.ltxmllib18.Conversions.ConversionType.TYPE_STRING, null, com.liquid_technologies.ltxmllib18.WhitespaceRule.PRESERVE, new com.liquid_technologies.ltxmllib18.PrimitiveRestrictions("", -1, -1, "", "", "", "", -1, -1, -1), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("prot", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getProt"), findSetterMethod("doxygenxml.compound.MemberdefType", "setProt", "doxygenxml.compound.DoxProtectionKind"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidProt"), getEnumFromString("doxygenxml.compound.DoxProtectionKind", "DoxProtectionKind"), getEnumToString("doxygenxml.compound.DoxProtectionKind", "DoxProtectionKind"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("static", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getStatic"), findSetterMethod("doxygenxml.compound.MemberdefType", "setStatic", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidStatic"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("strong", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getStrong"), findSetterMethod("doxygenxml.compound.MemberdefType", "setStrong", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidStrong"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("const", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getConst"), findSetterMethod("doxygenxml.compound.MemberdefType", "setConst", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidConst"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("explicit", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getExplicit"), findSetterMethod("doxygenxml.compound.MemberdefType", "setExplicit", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidExplicit"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("inline", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getInline"), findSetterMethod("doxygenxml.compound.MemberdefType", "setInline", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidInline"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("refqual", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getRefqual"), findSetterMethod("doxygenxml.compound.MemberdefType", "setRefqual", "doxygenxml.compound.DoxRefQualifierKind"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidRefqual"), getEnumFromString("doxygenxml.compound.DoxRefQualifierKind", "DoxRefQualifierKind"), getEnumToString("doxygenxml.compound.DoxRefQualifierKind", "DoxRefQualifierKind"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("virt", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getVirt"), findSetterMethod("doxygenxml.compound.MemberdefType", "setVirt", "doxygenxml.compound.DoxVirtualKind"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidVirt"), getEnumFromString("doxygenxml.compound.DoxVirtualKind", "DoxVirtualKind"), getEnumToString("doxygenxml.compound.DoxVirtualKind", "DoxVirtualKind"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("volatile", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getVolatile"), findSetterMethod("doxygenxml.compound.MemberdefType", "setVolatile", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidVolatile"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("mutable", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getMutable"), findSetterMethod("doxygenxml.compound.MemberdefType", "setMutable", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidMutable"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("noexcept", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getNoexcept"), findSetterMethod("doxygenxml.compound.MemberdefType", "setNoexcept", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidNoexcept"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("constexpr", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getConstexpr"), findSetterMethod("doxygenxml.compound.MemberdefType", "setConstexpr", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidConstexpr"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("readable", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getReadable"), findSetterMethod("doxygenxml.compound.MemberdefType", "setReadable", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidReadable"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("writable", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getWritable"), findSetterMethod("doxygenxml.compound.MemberdefType", "setWritable", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidWritable"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("initonly", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getInitonly"), findSetterMethod("doxygenxml.compound.MemberdefType", "setInitonly", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidInitonly"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("settable", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getSettable"), findSetterMethod("doxygenxml.compound.MemberdefType", "setSettable", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidSettable"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("privatesettable", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getPrivatesettable"), findSetterMethod("doxygenxml.compound.MemberdefType", "setPrivatesettable", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidPrivatesettable"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("protectedsettable", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getProtectedsettable"), findSetterMethod("doxygenxml.compound.MemberdefType", "setProtectedsettable", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidProtectedsettable"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("gettable", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getGettable"), findSetterMethod("doxygenxml.compound.MemberdefType", "setGettable", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidGettable"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("privategettable", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getPrivategettable"), findSetterMethod("doxygenxml.compound.MemberdefType", "setPrivategettable", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidPrivategettable"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("protectedgettable", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getProtectedgettable"), findSetterMethod("doxygenxml.compound.MemberdefType", "setProtectedgettable", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidProtectedgettable"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("final", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getFinal"), findSetterMethod("doxygenxml.compound.MemberdefType", "setFinal", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidFinal"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("sealed", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getSealed"), findSetterMethod("doxygenxml.compound.MemberdefType", "setSealed", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidSealed"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("new", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getNew"), findSetterMethod("doxygenxml.compound.MemberdefType", "setNew", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidNew"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("add", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getAdd"), findSetterMethod("doxygenxml.compound.MemberdefType", "setAdd", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidAdd"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("remove", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getRemove"), findSetterMethod("doxygenxml.compound.MemberdefType", "setRemove", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidRemove"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("raise", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getRaise"), findSetterMethod("doxygenxml.compound.MemberdefType", "setRaise", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidRaise"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("optional", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getOptional"), findSetterMethod("doxygenxml.compound.MemberdefType", "setOptional", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidOptional"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("required", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getRequired"), findSetterMethod("doxygenxml.compound.MemberdefType", "setRequired", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidRequired"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("accessor", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getAccessor"), findSetterMethod("doxygenxml.compound.MemberdefType", "setAccessor", "doxygenxml.compound.DoxAccessor"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidAccessor"), getEnumFromString("doxygenxml.compound.DoxAccessor", "DoxAccessor"), getEnumToString("doxygenxml.compound.DoxAccessor", "DoxAccessor"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("attribute", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getAttribute"), findSetterMethod("doxygenxml.compound.MemberdefType", "setAttribute", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidAttribute"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("property", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getProperty"), findSetterMethod("doxygenxml.compound.MemberdefType", "setProperty", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidProperty"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("readonly", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getReadonly"), findSetterMethod("doxygenxml.compound.MemberdefType", "setReadonly", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidReadonly"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("bound", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getBound"), findSetterMethod("doxygenxml.compound.MemberdefType", "setBound", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidBound"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("removable", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getRemovable"), findSetterMethod("doxygenxml.compound.MemberdefType", "setRemovable", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidRemovable"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("constrained", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getConstrained"), findSetterMethod("doxygenxml.compound.MemberdefType", "setConstrained", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidConstrained"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("transient", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getTransient"), findSetterMethod("doxygenxml.compound.MemberdefType", "setTransient", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidTransient"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("maybevoid", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getMaybevoid"), findSetterMethod("doxygenxml.compound.MemberdefType", "setMaybevoid", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidMaybevoid"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("maybedefault", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getMaybedefault"), findSetterMethod("doxygenxml.compound.MemberdefType", "setMaybedefault", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidMaybedefault"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
				,new com.liquid_technologies.ltxmllib18.data.AttributeInfoEnum("maybeambiguous", "", findGetterMethod("doxygenxml.compound.MemberdefType", "getMaybeambiguous"), findSetterMethod("doxygenxml.compound.MemberdefType", "setMaybeambiguous", "doxygenxml.compound.DoxBool"), findGetterMethod("doxygenxml.compound.MemberdefType", "isValidMaybeambiguous"), getEnumFromString("doxygenxml.compound.DoxBool", "DoxBool"), getEnumToString("doxygenxml.compound.DoxBool", "DoxBool"), null)
			};
		}
		return __attributeInfo;
	}

// ##HAND_CODED_BLOCK_START ID="Additional Methods"## DO NOT MODIFY ANYTHING OUTSIDE OF THESE TAGS

// Add Additional Methods and members here...

// ##HAND_CODED_BLOCK_END ID="Additional Methods"## DO NOT MODIFY ANYTHING OUTSIDE OF THESE TAGS
}


